home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Highlands / Highlands Tiny.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.7 KB  |  1,502 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Highlands Tiny.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Author: Scott Marison $
  10. // $Date: 8/28/01 3:36p $
  11. // $Revision: 21 $
  12. // $Revision: 21 $Revision: 8 By Rick Goodman
  13. //   Adjusted Angle between team members 
  14. // $Revision:
  15. //  Revision: 13 Lowered elevation, added neutrals, pushed players outward,
  16. //               lowered player outer radius, increased tree %, reduced
  17. //               forest free radius, reduced resource to edge distance
  18. //             Assumes Highlands Initial Step = 8
  19. //  Revision: 15 Revised for miniaturization 
  20. //  Revision: 16 Elevation 
  21. //  Revision: 17 Revised # of resources 3 by 3
  22. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  23. //  Revision: 19 Increased map size from 32 to 42
  24. //  Revision: 20 Reduced congestion 
  25. //  Revision: 23 Reduced Resources
  26. //  Revision: 24 Added Chance of steep cliffs 
  27. //  Revision: 25 Two forage sites for Prehistoric Start 
  28. //  Revision: 26 Evened-out resource distribution
  29. //  Revision: 26b Created neutral berry bushes for Prehistoric starts
  30. //
  31. //////////////////////////////////////////////////////////////////////
  32.  
  33. #if            NOTDEFINED(HIGHLANDS_TINY_RMV)
  34. #define        (HIGHLANDS_TINY_RMV,1)
  35.  
  36. //////////////////////////////////////////////////////////////////////
  37. // Definitions we are required to define for highlands maps
  38. //////////////////////////////////////////////////////////////////////
  39.  
  40. ResourcePlacementLimit (Gold,     8,    10)
  41. ResourcePlacementLimit (Steel,     8,     10)
  42. ResourcePlacementLimit (Stone,     8,     10)
  43. ResourcePlacementLimit (Berry,     8,     10)
  44. ResourcePlacementLimit (Fish,     1,    50)
  45. ResourcePlacementLimit (Tree,     3,     5)
  46. ResourcePlacementLimit (Animal,     7,     15)
  47.  
  48.  
  49. #if Is2Players
  50. //////////////////////////////////////////////////////////////////////
  51. // 2 PLAYERS...
  52. //////////////////////////////////////////////////////////////////////
  53.  
  54. //////////////////////////////////////////////////////////////////////
  55. // terrain definitions
  56. #define        (kMaxIntElevation,            8)
  57. #define        (kElevationScale,                Between(1, 1))
  58. #define        (kHeightMapChaos,                Between(12, 20))
  59.                                             
  60. #define        (kMinimumStartPositionToMapEdge    3)
  61. #define        (kOuterPushFromMapCenter        20)
  62. #define        (kInnerPushFromMapCenter         0)    
  63.  
  64. #define        (kConvergentSampleSize,            32) 
  65. #define        (kConvergentThreshold,            20000)    
  66.  
  67. //////////////////////////////////////////////////////////////////////
  68. // player definitions
  69. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  70. #define        (kPlayerInnerRadius,            0.7)
  71. #define        (kPlayerOuterRadius,            0.7)
  72. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  73. #define        (kPlayerPercentFlat,            Between(0.99, 0.99))
  74. #define        (kPlayerLandChaos,            0.8)
  75. #define        (kPlayerLandClumps,            Between(1, 1))
  76. #define        (kPlayerFlatChaos,            0.8)
  77. #define        (kPlayerFlatClumps,            Between(1, 1))
  78. #define        (kPlayerTreePercentage,            0.04)
  79.  
  80.  
  81. //////////////////////////////////////////////////////////////////////
  82. // inner neutral definitions
  83. #define        (kNeutralInnerRadius,            0.2)
  84. #define        (kNeutralOuterRadius,            0.4)
  85. #define        (kNeutralOptimalFactor,            0.7)
  86. #define        (kNumInnerNeutrals,                 Between(2, 2))
  87. #define        (kInnerNeutralPercentLand,        0.12)
  88. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  89. #define        (kInnerNeutralTreePercentage,          0.2)
  90. #define        (kInnerNeutralLandChaos,        0.8)
  91. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  92. #define        (kInnerNeutralFlatChaos,        0.8)
  93. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  94.  
  95.  
  96. //////////////////////////////////////////////////////////////////////
  97. // outer neutral definitions
  98. #define        (kNumOuterNeutrals,            Between(4, 4))
  99. #define        (kOuterNeutralPercentLand,        0.3)
  100. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  101. #define        (kOuterNeutralTreePercentage,          0.20)
  102. #define        (kOuterNeutralLandChaos,        0.8)
  103. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  104. #define        (kOuterNeutralFlatChaos,        0.8)
  105. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  106.  
  107.  
  108. //////////////////////////////////////////////////////////////////////
  109. // resource definitions
  110. #define        (kMaxResourceElevation,            3)
  111. #define        (kResourceToEdgeDistance,        2)
  112. #define        (kResourceToWaterDistance,        3)
  113.  
  114. #define        (kAnimalPerPlayer,            0)
  115. #define        (kAnimalPerNeutral,            0)
  116.  
  117. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  118.   #define  (kBerryPerPlayer,    1) 
  119.   #define  (kBerryPerNeutral,      3)
  120. #else
  121.   #define  (kBerryPerPlayer,    1)
  122.   #define  (kBerryPerNeutral,      0)
  123. #endif 
  124.  
  125. #define        (kFishPerPlayer,                0)
  126. #define        (kFishPerNeutral,                0)
  127.  
  128. #define        (kGoldPerPlayer,                1)
  129. #define        (kGoldPerNeutral,                3)
  130.  
  131. #define        (kOilPerPlayer,                0)
  132. #define        (kOilPerNeutral,                0)
  133.  
  134. #define        (kSteelPerPlayer,                1)
  135. #define        (kSteelPerNeutral,            3)
  136.  
  137. #define        (kStonePerPlayer,                1)
  138. #define        (kStonePerNeutral,            2)
  139.  
  140. #define        (kTreePerPlayer,                1)
  141. #define        (kTreePerNeutral,                0)
  142.  
  143.  
  144. //////////////////////////////////////////////////////////////////////
  145. // forest definitions
  146. #define        (kForestFreeRadius,                6.0)
  147. #define        (kForestsPerPlayer,                1)
  148. #define        (kForestChaosLevel,                1)
  149. #define        (kMaxClumpsPerForest,                  1)
  150.  
  151. #elif Is3Players
  152. //////////////////////////////////////////////////////////////////////
  153. // 3 PLAYERS...
  154. //////////////////////////////////////////////////////////////////////
  155.  
  156. //////////////////////////////////////////////////////////////////////
  157. // terrain definitions
  158. #define        (kMaxIntElevation,            8)
  159. #define        (kElevationScale,                Between(1, 1))
  160. #define        (kHeightMapChaos,                Between(12, 20))
  161.  
  162. #define        (kMinimumStartPositionToMapEdge    3)
  163. #define        (kOuterPushFromMapCenter        20)
  164. #define        (kInnerPushFromMapCenter         0)    
  165.     
  166. #define        (kConvergentSampleSize,            4) 
  167. #define        (kConvergentThreshold,            10) 
  168.                                             
  169. //////////////////////////////////////////////////////////////////////
  170. // player definitions
  171. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  172. #define        (kPlayerInnerRadius,            0.6)
  173. #define        (kPlayerOuterRadius,            0.9)
  174. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  175. #define        (kPlayerPercentFlat,            Between(0.98, 0.98))
  176. #define        (kPlayerLandChaos,            0.8)
  177. #define        (kPlayerLandClumps,            Between(1, 1))
  178. #define        (kPlayerFlatChaos,            0.8)
  179. #define        (kPlayerFlatClumps,            Between(1, 1))
  180. #define        (kPlayerTreePercentage,            0.05)
  181.  
  182.  
  183. //////////////////////////////////////////////////////////////////////
  184. // inner neutral definitions
  185. #define        (kNeutralInnerRadius,            0.05)
  186. #define        (kNeutralOuterRadius,            0.1)
  187. #define        (kNeutralOptimalFactor,            0.7)
  188. #define        (kNumInnerNeutrals,            Between(1, 1))
  189. #define        (kInnerNeutralPercentLand,        0.15)
  190. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  191. #define        (kInnerNeutralTreePercentage,          0.06)
  192. #define        (kInnerNeutralLandChaos,        0.8)
  193. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  194. #define        (kInnerNeutralFlatChaos,        0.8)
  195. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  196.  
  197. //////////////////////////////////////////////////////////////////////
  198. // outer neutral definitions
  199. #define        (kNumOuterNeutrals,            Between(3, 3))
  200. #define        (kOuterNeutralPercentLand,        0.18)
  201. #define        (kOuterNeutralPercentFlat,        Between(0.79, 0.79))
  202. #define        (kOuterNeutralTreePercentage,          0.1)
  203. #define        (kOuterNeutralLandChaos,        0.8)
  204. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  205. #define        (kOuterNeutralFlatChaos,        0.8)
  206. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  207.  
  208. //////////////////////////////////////////////////////////////////////
  209. // resource definitions
  210. #define        (kMaxResourceElevation,            3)
  211. #define        (kResourceToEdgeDistance,        2)
  212. #define        (kResourceToWaterDistance,        4)
  213.  
  214. #define        (kAnimalPerPlayer,            0)
  215. #define        (kAnimalPerNeutral,            0)
  216.  
  217. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  218.   #define  (kBerryPerPlayer,    1) 
  219.   #define  (kBerryPerNeutral,      5)
  220. #else
  221.   #define  (kBerryPerPlayer,    1)
  222.   #define  (kBerryPerNeutral,      0)
  223. #endif 
  224.  
  225. #define        (kFishPerPlayer,                0)
  226. #define        (kFishPerNeutral,                0)
  227.  
  228. #define        (kGoldPerPlayer,                1)
  229. #define        (kGoldPerNeutral,                5)
  230.  
  231. #define        (kOilPerPlayer,                0)
  232. #define        (kOilPerNeutral,                0)
  233.  
  234. #define        (kSteelPerPlayer,                1)
  235. #define        (kSteelPerNeutral,            5)
  236.  
  237. #define        (kStonePerPlayer,                1)
  238. #define        (kStonePerNeutral,            2)
  239.  
  240. #define        (kTreePerPlayer,                1)
  241. #define        (kTreePerNeutral,                0)
  242.  
  243.  
  244. //////////////////////////////////////////////////////////////////////
  245. // forest definitions
  246. #define        (kForestFreeRadius,                6.0)
  247. #define        (kForestsPerPlayer,                1)
  248. #define        (kForestChaosLevel,                1)
  249. #define        (kMaxClumpsPerForest,                  1)
  250.  
  251. #elif Is4Players
  252. //////////////////////////////////////////////////////////////////////
  253. // 4 PLAYERS...
  254. //////////////////////////////////////////////////////////////////////
  255.  
  256. //////////////////////////////////////////////////////////////////////
  257. // terrain definitions
  258. #define        (kMaxIntElevation,            8)
  259. #define        (kElevationScale,                Between(1, 1))
  260. #define        (kHeightMapChaos,                Between(12, 18))
  261.                         
  262. #define        (kMinimumStartPositionToMapEdge    3)
  263. #define        (kOuterPushFromMapCenter        20)
  264. #define        (kInnerPushFromMapCenter         0)    
  265.  
  266. #define        (kConvergentSampleSize,            4) 
  267. #define        (kConvergentThreshold,            10) 
  268.                     
  269. //////////////////////////////////////////////////////////////////////
  270. // player definitions
  271. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  272. #define        (kPlayerInnerRadius,            0.7)
  273. #define        (kPlayerOuterRadius,            0.99)
  274. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  275. #define        (kPlayerPercentFlat,            Between(0.97, 0.97))
  276. #define        (kPlayerLandChaos,            0.8)
  277. #define        (kPlayerLandClumps,            Between(1, 1))
  278. #define        (kPlayerFlatChaos,            0.8)
  279. #define        (kPlayerFlatClumps,            Between(1, 1))
  280. #define        (kPlayerTreePercentage,            0.06)
  281.  
  282.  
  283. //////////////////////////////////////////////////////////////////////
  284. // inner neutral definitions
  285. #define        (kNeutralInnerRadius,            0.05)
  286. #define        (kNeutralOuterRadius,            0.1)
  287. #define        (kNeutralOptimalFactor,            0.7)
  288. #define        (kNumInnerNeutrals,                 Between(1, 1))
  289. #define        (kInnerNeutralPercentLand,        0.15)
  290. #define        (kInnerNeutralPercentFlat,        Between(0.7, 0.7))
  291. #define        (kInnerNeutralTreePercentage,          0.06)
  292. #define        (kInnerNeutralLandChaos,        0.8)
  293. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  294. #define        (kInnerNeutralFlatChaos,        0.8)
  295. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  296.  
  297. //////////////////////////////////////////////////////////////////////
  298. // outer neutral definitions
  299. #define        (kNumOuterNeutrals,            Between(2, 2))
  300. #define        (kOuterNeutralPercentLand,        0.2)
  301. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  302. #define        (kOuterNeutralTreePercentage,          0.15)
  303. #define        (kOuterNeutralLandChaos,        0.8)
  304. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  305. #define        (kOuterNeutralFlatChaos,        0.8)
  306. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  307.  
  308. //////////////////////////////////////////////////////////////////////
  309. // resource definitions
  310. #define        (kMaxResourceElevation,            3)
  311. #define        (kResourceToEdgeDistance,        2)
  312. #define        (kResourceToWaterDistance,        4)
  313.  
  314. #define        (kAnimalPerPlayer,            0)
  315. #define        (kAnimalPerNeutral,            0)
  316.  
  317. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  318.   #define  (kBerryPerPlayer,    1) 
  319.   #define  (kBerryPerNeutral,      4)
  320. #else
  321.   #define  (kBerryPerPlayer,    1)
  322.   #define  (kBerryPerNeutral,      0)
  323. #endif 
  324.  
  325. #define        (kFishPerPlayer,                0)
  326. #define        (kFishPerNeutral,                0)
  327.  
  328. #define        (kGoldPerPlayer,                1)
  329. #define        (kGoldPerNeutral,                6)
  330.  
  331. #define        (kOilPerPlayer,                0)
  332. #define        (kOilPerNeutral,                0)
  333.  
  334. #define        (kSteelPerPlayer,                1)
  335. #define        (kSteelPerNeutral,            6)
  336.  
  337. #define        (kStonePerPlayer,                1)
  338. #define        (kStonePerNeutral,            2)
  339.  
  340. #define        (kTreePerPlayer,                1)
  341. #define        (kTreePerNeutral,                0)
  342.  
  343.  
  344. //////////////////////////////////////////////////////////////////////
  345. // forest definitions
  346. #define        (kForestFreeRadius,                6.0)
  347. #define        (kForestsPerPlayer,                1)
  348. #define        (kForestChaosLevel,                1)
  349. #define        (kMaxClumpsPerForest,                  1)
  350.  
  351. #elif Is5Players
  352. //////////////////////////////////////////////////////////////////////
  353. // 5 PLAYERS...
  354. //////////////////////////////////////////////////////////////////////
  355.  
  356. //////////////////////////////////////////////////////////////////////
  357. // terrain definitions
  358. #define        (kMaxIntElevation,            8)
  359. #define        (kElevationScale,                Between(1, 1))
  360. #define        (kHeightMapChaos,                Between(12, 18))
  361.  
  362. #define        (kMinimumStartPositionToMapEdge    1)
  363. #define        (kOuterPushFromMapCenter        20)
  364. #define        (kInnerPushFromMapCenter         0)    
  365.  
  366. #define        (kConvergentSampleSize,            5) 
  367. #define        (kConvergentThreshold,            8)    
  368.                                             
  369. //////////////////////////////////////////////////////////////////////
  370. // player definitions
  371. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  372. #define        (kPlayerInnerRadius,            0.6)
  373. #define        (kPlayerOuterRadius,            0.99)
  374. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  375. #define        (kPlayerPercentFlat,            Between(0.96, 0.96))
  376. #define        (kPlayerLandChaos,            0.8)
  377. #define        (kPlayerLandClumps,            Between(1, 1))
  378. #define        (kPlayerFlatChaos,            0.8)
  379. #define        (kPlayerFlatClumps,            Between(1, 1))
  380. #define        (kPlayerTreePercentage,            0.06)
  381.  
  382.  
  383. //////////////////////////////////////////////////////////////////////
  384. // inner neutral definitions
  385. #define        (kNeutralInnerRadius,            0.05)
  386. #define        (kNeutralOuterRadius,            0.2)
  387. #define        (kNeutralOptimalFactor,            0.7)
  388. #define        (kNumInnerNeutrals,                 Between(1, 1))
  389. #define        (kInnerNeutralPercentLand,        0.12)
  390. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  391. #define        (kInnerNeutralTreePercentage,          0.07)
  392. #define        (kInnerNeutralLandChaos,        0.8)
  393. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  394. #define        (kInnerNeutralFlatChaos,        0.8)
  395. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  396.  
  397.  
  398. //////////////////////////////////////////////////////////////////////
  399. // outer neutral definitions
  400. #define        (kNumOuterNeutrals,            Between(0, 0))
  401. #define        (kOuterNeutralPercentLand,        0.35)
  402. #define        (kOuterNeutralPercentFlat,        Between(0.8, 0.8))
  403. #define        (kOuterNeutralTreePercentage,          0.20)
  404. #define        (kOuterNeutralLandChaos,        0.8)
  405. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  406. #define        (kOuterNeutralFlatChaos,        0.8)
  407. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  408.  
  409. //////////////////////////////////////////////////////////////////////
  410. // resource definitions
  411. #define        (kMaxResourceElevation,            3)
  412. #define        (kResourceToEdgeDistance,        1)
  413. #define        (kResourceToWaterDistance,        4)
  414.  
  415. #define        (kAnimalPerPlayer,            0)
  416. #define        (kAnimalPerNeutral,            0)
  417.  
  418. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  419.   #define  (kBerryPerPlayer,    2)
  420. #else
  421.   #define  (kBerryPerPlayer,    1)
  422. #endif 
  423.  
  424. #define        (kBerryPerNeutral,            0)
  425.  
  426. #define        (kFishPerPlayer,                0)
  427. #define        (kFishPerNeutral,                0)
  428.  
  429. #define        (kGoldPerPlayer,                2)
  430. #define        (kGoldPerNeutral,                1)
  431.  
  432. #define        (kOilPerPlayer,                0)
  433. #define        (kOilPerNeutral,                0)
  434.  
  435. #define        (kSteelPerPlayer,                2)
  436. #define        (kSteelPerNeutral,            1)
  437.  
  438. #define        (kStonePerPlayer,                1)
  439. #define        (kStonePerNeutral,            2)
  440.  
  441. #define        (kTreePerPlayer,                1)
  442. #define        (kTreePerNeutral,                0)
  443.  
  444.  
  445. //////////////////////////////////////////////////////////////////////
  446. // forest definitions
  447. #define        (kForestFreeRadius,                6.0)
  448. #define        (kForestsPerPlayer,                1)
  449. #define        (kForestChaosLevel,                1)
  450. #define        (kMaxClumpsPerForest,                  1)
  451.  
  452.  
  453. #elif Is6Players
  454. //////////////////////////////////////////////////////////////////////
  455. // 6 PLAYERS...
  456. //////////////////////////////////////////////////////////////////////
  457.  
  458. //////////////////////////////////////////////////////////////////////
  459. // terrain definitions
  460. #define        (kMaxIntElevation,            8)
  461. #define        (kElevationScale,                Between(1, 1))
  462. #define        (kHeightMapChaos,                Between(12, 18))
  463.  
  464. #define        (kMinimumStartPositionToMapEdge    1)
  465. #define        (kOuterPushFromMapCenter        20)
  466. #define        (kInnerPushFromMapCenter         0)    
  467.  
  468. #define        (kConvergentSampleSize,            32) 
  469. #define        (kConvergentThreshold,            1) 
  470.                                             
  471. //////////////////////////////////////////////////////////////////////
  472. // player definitions
  473. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  474. #define        (kPlayerInnerRadius,            0.6)
  475. #define        (kPlayerOuterRadius,            0.99)
  476. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  477. #define        (kPlayerPercentFlat,            Between(0.95, 0.95))
  478. #define        (kPlayerLandChaos,            0.8)
  479. #define        (kPlayerLandClumps,            Between(1, 1))
  480. #define        (kPlayerFlatChaos,            0.8)
  481. #define        (kPlayerFlatClumps,            Between(1, 1))
  482. #define        (kPlayerTreePercentage,            0.06)
  483.  
  484.  
  485. //////////////////////////////////////////////////////////////////////
  486. // inner neutral definitions
  487. #define        (kNeutralInnerRadius,            0.05)
  488. #define        (kNeutralOuterRadius,            0.2)
  489. #define        (kNeutralOptimalFactor,            0.7)
  490. #define        (kNumInnerNeutrals,                 Between(1, 1))
  491. #define        (kInnerNeutralPercentLand,        0.17)
  492. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  493. #define        (kInnerNeutralTreePercentage,          0.06)
  494. #define        (kInnerNeutralLandChaos,        0.8)
  495. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  496. #define        (kInnerNeutralFlatChaos,        0.8)
  497. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  498.  
  499. //////////////////////////////////////////////////////////////////////
  500. // outer neutral definitions
  501. #define        (kNumOuterNeutrals,            Between(0, 0))
  502. #define        (kOuterNeutralPercentLand,        0.3)
  503. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  504. #define        (kOuterNeutralTreePercentage,          0.17)
  505. #define        (kOuterNeutralLandChaos,        0.8)
  506. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  507. #define        (kOuterNeutralFlatChaos,        0.8)
  508. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  509.  
  510. //////////////////////////////////////////////////////////////////////
  511. // resource definitions
  512. #define        (kMaxResourceElevation,            3)
  513. #define        (kResourceToEdgeDistance,        1)
  514. #define        (kResourceToWaterDistance,        4)
  515.  
  516. #define        (kAnimalPerPlayer,            0)
  517. #define        (kAnimalPerNeutral,            0)
  518.  
  519. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  520.   #define  (kBerryPerPlayer,    2)
  521. #else
  522.   #define  (kBerryPerPlayer,    1)
  523. #endif 
  524.  
  525. #define        (kBerryPerNeutral,            0)
  526.  
  527. #define        (kFishPerPlayer,                0)
  528. #define        (kFishPerNeutral,                0)
  529.  
  530. #define        (kGoldPerPlayer,                2)
  531. #define        (kGoldPerNeutral,                0)
  532.  
  533. #define        (kOilPerPlayer,                0)
  534. #define        (kOilPerNeutral,                0)
  535.  
  536. #define        (kSteelPerPlayer,                2)
  537. #define        (kSteelPerNeutral,            0)
  538.  
  539. #define        (kStonePerPlayer,                1)
  540. #define        (kStonePerNeutral,            2)
  541.  
  542. #define        (kTreePerPlayer,                1)
  543. #define        (kTreePerNeutral,                0)
  544.  
  545.  
  546. //////////////////////////////////////////////////////////////////////
  547. // forest definitions
  548. #define        (kForestFreeRadius,                6.0)
  549. #define        (kForestsPerPlayer,                1)
  550. #define        (kForestChaosLevel,                1)
  551. #define        (kMaxClumpsPerForest,                  1)
  552.  
  553.  
  554. #elif Is7Players
  555. //////////////////////////////////////////////////////////////////////
  556. // 7 PLAYERS...
  557. //////////////////////////////////////////////////////////////////////
  558.  
  559. //////////////////////////////////////////////////////////////////////
  560. // terrain definitions
  561. #define        (kMaxIntElevation,            8)
  562. #define        (kElevationScale,                Between(1, 1))
  563. #define        (kHeightMapChaos,                Between(12, 18))
  564.  
  565. #define        (kMinimumStartPositionToMapEdge    1)
  566. #define        (kOuterPushFromMapCenter        20)
  567. #define        (kInnerPushFromMapCenter         0)    
  568.  
  569. #define        (kConvergentSampleSize,            32) 
  570. #define        (kConvergentThreshold,            1) 
  571.                                             
  572. //////////////////////////////////////////////////////////////////////
  573. // player definitions
  574. #define        (kMaxAngleBetweenTeamMembers,          50.0)
  575. #define        (kPlayerInnerRadius,            0.6)
  576. #define        (kPlayerOuterRadius,            0.99)
  577. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  578. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  579. #define        (kPlayerLandChaos,            0.8)
  580. #define        (kPlayerLandClumps,            Between(1, 1))
  581. #define        (kPlayerFlatChaos,            0.8)
  582. #define        (kPlayerFlatClumps,            Between(1, 1))
  583. #define        (kPlayerTreePercentage,            0.06)
  584.  
  585.  
  586. //////////////////////////////////////////////////////////////////////
  587. // inner neutral definitions
  588. #define        (kNeutralInnerRadius,            0.0)
  589. #define        (kNeutralOuterRadius,            0.1)
  590. #define        (kNeutralOptimalFactor,            0.7)
  591. #define        (kNumInnerNeutrals,                 Between(0, 0))
  592. #define        (kInnerNeutralPercentLand,        0.15)
  593. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  594. #define        (kInnerNeutralTreePercentage,          0.06)
  595. #define        (kInnerNeutralLandChaos,        0.8)
  596. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  597. #define        (kInnerNeutralFlatChaos,        0.8)
  598. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  599.  
  600. //////////////////////////////////////////////////////////////////////
  601. // outer neutral definitions
  602. #define        (kNumOuterNeutrals,            Between(0, 0))
  603. #define        (kOuterNeutralPercentLand,        0.25)
  604. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  605. #define        (kOuterNeutralTreePercentage,          0.20)
  606. #define        (kOuterNeutralLandChaos,        0.8)
  607. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  608. #define        (kOuterNeutralFlatChaos,        0.8)
  609. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  610.  
  611. //////////////////////////////////////////////////////////////////////
  612. // resource definitions
  613. #define        (kMaxResourceElevation,            3)
  614. #define        (kResourceToEdgeDistance,        1)
  615. #define        (kResourceToWaterDistance,        4)
  616.  
  617. #define        (kAnimalPerPlayer,            0)
  618. #define        (kAnimalPerNeutral,            0)
  619.  
  620. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  621.   #define  (kBerryPerPlayer,    2)
  622. #else
  623.   #define  (kBerryPerPlayer,    1)
  624. #endif 
  625.  
  626. #define        (kBerryPerNeutral,            0)
  627.  
  628. #define        (kFishPerPlayer,                0)
  629. #define        (kFishPerNeutral,                0)
  630.  
  631. #define        (kGoldPerPlayer,                1)
  632. #define        (kGoldPerNeutral,                3)
  633.  
  634. #define        (kOilPerPlayer,                0)
  635. #define        (kOilPerNeutral,                0)
  636.  
  637. #define        (kSteelPerPlayer,                1)
  638. #define        (kSteelPerNeutral,            3)
  639.  
  640. #define        (kStonePerPlayer,                1)
  641. #define        (kStonePerNeutral,            2)
  642.  
  643. #define        (kTreePerPlayer,                1)
  644. #define        (kTreePerNeutral,                0)
  645.  
  646.  
  647. //////////////////////////////////////////////////////////////////////
  648. // forest definitions
  649. #define        (kForestFreeRadius,                4.0)
  650. #define        (kForestsPerPlayer,                1)
  651. #define        (kForestChaosLevel,                1)
  652. #define        (kMaxClumpsPerForest,                  1)
  653.  
  654. #elif Is8Players
  655. //////////////////////////////////////////////////////////////////////
  656. // 8 PLAYERS...
  657. //////////////////////////////////////////////////////////////////////
  658.  
  659. //////////////////////////////////////////////////////////////////////
  660. // terrain definitions
  661. #define        (kMaxIntElevation,            8)
  662. #define        (kElevationScale,                Between(1, 1))
  663. #define        (kHeightMapChaos,                Between(12, 18))
  664.  
  665. #define        (kMinimumStartPositionToMapEdge    1)
  666. #define        (kOuterPushFromMapCenter        20)
  667. #define        (kInnerPushFromMapCenter         0)    
  668.  
  669. #define        (kConvergentSampleSize,            32) 
  670. #define        (kConvergentThreshold,            1) 
  671.                                             
  672. //////////////////////////////////////////////////////////////////////
  673. // player definitions
  674. #define        (kMaxAngleBetweenTeamMembers,        50.0)
  675. #define        (kPlayerInnerRadius,            0.6)
  676. #define        (kPlayerOuterRadius,            0.99)
  677. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  678. #define        (kPlayerPercentFlat,            Between(.91, .91))
  679. #define        (kPlayerLandChaos,            0.8)
  680. #define        (kPlayerLandClumps,            Between(1, 1))
  681. #define        (kPlayerFlatChaos,            0.8)
  682. #define        (kPlayerFlatClumps,            Between(1, 1))
  683. #define        (kPlayerTreePercentage,            0.05)
  684.  
  685. //////////////////////////////////////////////////////////////////////
  686. // inner neutral definitions
  687. #define        (kNeutralInnerRadius,            0.0)
  688. #define        (kNeutralOuterRadius,            0.1)
  689. #define        (kNeutralOptimalFactor,            0.7)
  690. #define        (kNumInnerNeutrals,                 Between(0, 0))
  691. #define        (kInnerNeutralPercentLand,        0.1)
  692. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  693. #define        (kInnerNeutralTreePercentage,          0.07)
  694. #define        (kInnerNeutralLandChaos,        0.8)
  695. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  696. #define        (kInnerNeutralFlatChaos,        0.8)
  697. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  698.  
  699. //////////////////////////////////////////////////////////////////////
  700. // outer neutral definitions
  701. #define        (kNumOuterNeutrals,            Between(0, 0))
  702. #define        (kOuterNeutralPercentLand,        0.2)
  703. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  704. #define        (kOuterNeutralTreePercentage,          0.0025)
  705. #define        (kOuterNeutralLandChaos,        0.8)
  706. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  707. #define        (kOuterNeutralFlatChaos,        0.8)
  708. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  709.  
  710. //////////////////////////////////////////////////////////////////////
  711. // resource definitions
  712. #define        (kMaxResourceElevation,            3)
  713. #define        (kResourceToEdgeDistance,        1)
  714. #define        (kResourceToWaterDistance,        4)
  715.  
  716. #define        (kAnimalPerPlayer,            0)
  717. #define        (kAnimalPerNeutral,            0)
  718.  
  719. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  720.   #define  (kBerryPerPlayer,    2)
  721. #else
  722.   #define  (kBerryPerPlayer,    1)
  723. #endif 
  724.  
  725. #define        (kBerryPerNeutral,            0)
  726.  
  727. #define        (kFishPerPlayer,                0)
  728. #define        (kFishPerNeutral,                0)
  729.  
  730. #define        (kGoldPerPlayer,                1)
  731. #define        (kGoldPerNeutral,                3)
  732.  
  733. #define        (kOilPerPlayer,                0)
  734. #define        (kOilPerNeutral,                0)
  735.  
  736. #define        (kSteelPerPlayer,                1)
  737. #define        (kSteelPerNeutral,            3)
  738.  
  739. #define        (kStonePerPlayer,                1)
  740. #define        (kStonePerNeutral,            2)
  741.  
  742. #define        (kTreePerPlayer,                1)
  743. #define        (kTreePerNeutral,                0)
  744.  
  745.  
  746. //////////////////////////////////////////////////////////////////////
  747. // forest definitions
  748. #define        (kForestFreeRadius,                4.0)
  749. #define        (kForestsPerPlayer,                1)
  750. #define        (kForestChaosLevel,                1)
  751. #define        (kMaxClumpsPerForest,                  1)
  752.  
  753. #elif Is9Players
  754. //////////////////////////////////////////////////////////////////////
  755. // 9 PLAYERS...
  756. //////////////////////////////////////////////////////////////////////
  757.  
  758. //////////////////////////////////////////////////////////////////////
  759. // terrain definitions
  760. #define        (kMaxIntElevation,            12)
  761. #define        (kElevationScale,                Between(1, 1))
  762. #define        (kHeightMapChaos,                Between(20, 50))
  763.  
  764. #define        (kMinimumStartPositionToMapEdge    1)
  765. #define        (kOuterPushFromMapCenter        20)
  766. #define        (kInnerPushFromMapCenter         0)    
  767.                                             
  768. //////////////////////////////////////////////////////////////////////
  769. // player definitions
  770. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  771. #define        (kPlayerInnerRadius,            0.6)
  772. #define        (kPlayerOuterRadius,            0.99)
  773. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  774. #define        (kPlayerPercentFlat,            Between(.95, .95))
  775. #define        (kPlayerLandChaos,            0.8)
  776. #define        (kPlayerLandClumps,            Between(2, 2))
  777. #define        (kPlayerFlatChaos,            0.8)
  778. #define        (kPlayerFlatClumps,            Between(1, 2))
  779. #define        (kPlayerTreePercentage,            0.15)
  780.  
  781. //////////////////////////////////////////////////////////////////////
  782. // inner neutral definitions
  783. #define        (kNeutralInnerRadius,            0.3)
  784. #define        (kNeutralOuterRadius,            0.4)
  785. #define        (kNeutralOptimalFactor,            0.7)
  786. #define        (kNumInnerNeutrals,                 Between(4, 4))
  787. #define        (kInnerNeutralPercentLand,        0.14)
  788. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  789. #define        (kInnerNeutralTreePercentage,          0.15)
  790. #define        (kInnerNeutralLandChaos,        0.8)
  791. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  792. #define        (kInnerNeutralFlatChaos,        0.8)
  793. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  794.  
  795. //////////////////////////////////////////////////////////////////////
  796. // outer neutral definitions
  797. #define        (kNumOuterNeutrals,            Between(9, 9))
  798. #define        (kOuterNeutralPercentLand,        0.3)
  799. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  800. #define        (kOuterNeutralTreePercentage,          0.2)
  801. #define        (kOuterNeutralLandChaos,        0.8)
  802. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  803. #define        (kOuterNeutralFlatChaos,        0.8)
  804. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  805.  
  806. //////////////////////////////////////////////////////////////////////
  807. // resource definitions
  808. #define        (kMaxResourceElevation,            3)
  809. #define        (kResourceToEdgeDistance,        2)
  810. #define        (kResourceToWaterDistance,        4)
  811.  
  812. #define        (kAnimalPerPlayer,            0)
  813. #define        (kAnimalPerNeutral,            0)
  814.  
  815. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  816.   #define  (kBerryPerPlayer,    2)
  817. #else
  818.   #define  (kBerryPerPlayer,    1)
  819. #endif 
  820.  
  821. #define        (kBerryPerNeutral,            0)
  822.  
  823. #define        (kFishPerPlayer,                0)
  824. #define        (kFishPerNeutral,                0)
  825.  
  826. #define        (kGoldPerPlayer,                1)
  827. #define        (kGoldPerNeutral,                6)
  828.  
  829. #define        (kOilPerPlayer,                0)
  830. #define        (kOilPerNeutral,                0)
  831.  
  832. #define        (kSteelPerPlayer,                1)
  833. #define        (kSteelPerNeutral,            6)
  834.  
  835. #define        (kStonePerPlayer,                1)
  836. #define        (kStonePerNeutral,            2)
  837.  
  838. #define        (kTreePerPlayer,                0)
  839. #define        (kTreePerNeutral,                0)
  840.  
  841.  
  842. //////////////////////////////////////////////////////////////////////
  843. // forest definitions
  844. #define        (kForestFreeRadius,                6.0)
  845. #define        (kForestsPerPlayer,                1 )
  846. #define        (kForestChaosLevel,                0.1)
  847. #define        (kMaxClumpsPerForest,                  2)
  848.  
  849.  
  850. #elif Is10Players
  851. //////////////////////////////////////////////////////////////////////
  852. // 10 PLAYERS...
  853. //////////////////////////////////////////////////////////////////////
  854.  
  855. //////////////////////////////////////////////////////////////////////
  856. // terrain definitions
  857. #define        (kMaxIntElevation,            12)
  858. #define        (kElevationScale,                Between(1, 1))
  859. #define        (kHeightMapChaos,                Between(20, 50))
  860.  
  861. #define        (kMinimumStartPositionToMapEdge    1)
  862. #define        (kOuterPushFromMapCenter        20)
  863. #define        (kInnerPushFromMapCenter         0)    
  864.                                             
  865. //////////////////////////////////////////////////////////////////////
  866. // player definitions
  867. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  868. #define        (kPlayerInnerRadius,            0.6)
  869. #define        (kPlayerOuterRadius,            0.99)
  870. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  871. #define        (kPlayerPercentFlat,            Between(.95, .95))
  872. #define        (kPlayerLandChaos,            0.8)
  873. #define        (kPlayerLandClumps,            Between(2, 2))
  874. #define        (kPlayerFlatChaos,            0.8)
  875. #define        (kPlayerFlatClumps,            Between(1, 2))
  876. #define        (kPlayerTreePercentage,            0.15)
  877.  
  878. //////////////////////////////////////////////////////////////////////
  879. // inner neutral definitions
  880. #define        (kNeutralInnerRadius,            0.3)
  881. #define        (kNeutralOuterRadius,            0.4)
  882. #define        (kNeutralOptimalFactor,            0.7)
  883. #define        (kNumInnerNeutrals,                 Between(4, 4))
  884. #define        (kInnerNeutralPercentLand,        0.14)
  885. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  886. #define        (kInnerNeutralTreePercentage,          0.15)
  887. #define        (kInnerNeutralLandChaos,        0.8)
  888. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  889. #define        (kInnerNeutralFlatChaos,        0.8)
  890. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  891.  
  892. //////////////////////////////////////////////////////////////////////
  893. // outer neutral definitions
  894. #define        (kNumOuterNeutrals,            Between(9, 9))
  895. #define        (kOuterNeutralPercentLand,        0.3)
  896. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  897. #define        (kOuterNeutralTreePercentage,          0.2)
  898. #define        (kOuterNeutralLandChaos,        0.8)
  899. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  900. #define        (kOuterNeutralFlatChaos,        0.8)
  901. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  902.  
  903. //////////////////////////////////////////////////////////////////////
  904. // resource definitions
  905. #define        (kMaxResourceElevation,            3)
  906. #define        (kResourceToEdgeDistance,        2)
  907. #define        (kResourceToWaterDistance,        4)
  908.  
  909. #define        (kAnimalPerPlayer,            0)
  910. #define        (kAnimalPerNeutral,            0)
  911.  
  912. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  913.   #define  (kBerryPerPlayer,    2)
  914. #else
  915.   #define  (kBerryPerPlayer,    1)
  916. #endif 
  917.  
  918. #define        (kBerryPerNeutral,            0)
  919.  
  920. #define        (kFishPerPlayer,                0)
  921. #define        (kFishPerNeutral,                0)
  922.  
  923. #define        (kGoldPerPlayer,                1)
  924. #define        (kGoldPerNeutral,                6)
  925.  
  926. #define        (kOilPerPlayer,                0)
  927. #define        (kOilPerNeutral,                0)
  928.  
  929. #define        (kSteelPerPlayer,                1)
  930. #define        (kSteelPerNeutral,            6)
  931.  
  932. #define        (kStonePerPlayer,                1)
  933. #define        (kStonePerNeutral,            2)
  934.  
  935. #define        (kTreePerPlayer,                0)
  936. #define        (kTreePerNeutral,                0)
  937.  
  938.  
  939. //////////////////////////////////////////////////////////////////////
  940. // forest definitions
  941. #define        (kForestFreeRadius,                6.0)
  942. #define        (kForestsPerPlayer,                1 )
  943. #define        (kForestChaosLevel,                0.1)
  944. #define        (kMaxClumpsPerForest,                  2)
  945.  
  946. #elif Is11Players
  947. //////////////////////////////////////////////////////////////////////
  948. // 11 PLAYERS...
  949. //////////////////////////////////////////////////////////////////////
  950.  
  951. //////////////////////////////////////////////////////////////////////
  952. // terrain definitions
  953. #define        (kMaxIntElevation,            12)
  954. #define        (kElevationScale,                Between(1, 1))
  955. #define        (kHeightMapChaos,                Between(20, 50))
  956.  
  957. #define        (kMinimumStartPositionToMapEdge    1)
  958. #define        (kOuterPushFromMapCenter        20)
  959. #define        (kInnerPushFromMapCenter         0)    
  960.                                             
  961. //////////////////////////////////////////////////////////////////////
  962. // player definitions
  963. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  964. #define        (kPlayerInnerRadius,            0.6)
  965. #define        (kPlayerOuterRadius,            0.99)
  966. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  967. #define        (kPlayerPercentFlat,            Between(.95, .95))
  968. #define        (kPlayerLandChaos,            0.8)
  969. #define        (kPlayerLandClumps,            Between(2, 2))
  970. #define        (kPlayerFlatChaos,            0.8)
  971. #define        (kPlayerFlatClumps,            Between(1, 2))
  972. #define        (kPlayerTreePercentage,            0.15)
  973.  
  974. //////////////////////////////////////////////////////////////////////
  975. // inner neutral definitions
  976. #define        (kNeutralInnerRadius,            0.3)
  977. #define        (kNeutralOuterRadius,            0.4)
  978. #define        (kNeutralOptimalFactor,            0.7)
  979. #define        (kNumInnerNeutrals,                 Between(4, 4))
  980. #define        (kInnerNeutralPercentLand,        0.14)
  981. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  982. #define        (kInnerNeutralTreePercentage,          0.15)
  983. #define        (kInnerNeutralLandChaos,        0.8)
  984. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  985. #define        (kInnerNeutralFlatChaos,        0.8)
  986. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  987.  
  988. //////////////////////////////////////////////////////////////////////
  989. // outer neutral definitions
  990. #define        (kNumOuterNeutrals,            Between(9, 9))
  991. #define        (kOuterNeutralPercentLand,        0.3)
  992. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  993. #define        (kOuterNeutralTreePercentage,          0.2)
  994. #define        (kOuterNeutralLandChaos,        0.8)
  995. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  996. #define        (kOuterNeutralFlatChaos,        0.8)
  997. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  998.  
  999. //////////////////////////////////////////////////////////////////////
  1000. // resource definitions
  1001. #define        (kMaxResourceElevation,            3)
  1002. #define        (kResourceToEdgeDistance,        2)
  1003. #define        (kResourceToWaterDistance,        4)
  1004.  
  1005. #define        (kAnimalPerPlayer,            0)
  1006. #define        (kAnimalPerNeutral,            0)
  1007.  
  1008. #define        (kBerryPerPlayer,                1)
  1009. #define        (kBerryPerNeutral,            0)
  1010.  
  1011. #define        (kFishPerPlayer,                0)
  1012. #define        (kFishPerNeutral,                0)
  1013.  
  1014. #define        (kGoldPerPlayer,                1)
  1015. #define        (kGoldPerNeutral,                6)
  1016.  
  1017. #define        (kOilPerPlayer,                0)
  1018. #define        (kOilPerNeutral,                0)
  1019.  
  1020. #define        (kSteelPerPlayer,                1)
  1021. #define        (kSteelPerNeutral,            6)
  1022.  
  1023. #define        (kStonePerPlayer,                1)
  1024. #define        (kStonePerNeutral,            2)
  1025.  
  1026. #define        (kTreePerPlayer,                0)
  1027. #define        (kTreePerNeutral,                0)
  1028.  
  1029.  
  1030. //////////////////////////////////////////////////////////////////////
  1031. // forest definitions
  1032. #define        (kForestFreeRadius,                6.0)
  1033. #define        (kForestsPerPlayer,                1 )
  1034. #define        (kForestChaosLevel,                0.1)
  1035. #define        (kMaxClumpsPerForest,                  2)
  1036.  
  1037. #elif Is12Players
  1038. //////////////////////////////////////////////////////////////////////
  1039. // 12 PLAYERS...
  1040. //////////////////////////////////////////////////////////////////////
  1041.  
  1042. //////////////////////////////////////////////////////////////////////
  1043. // terrain definitions
  1044. #define        (kMaxIntElevation,            12)
  1045. #define        (kElevationScale,                Between(1, 1))
  1046. #define        (kHeightMapChaos,                Between(20, 50))
  1047.  
  1048. #define        (kMinimumStartPositionToMapEdge    1)
  1049. #define        (kOuterPushFromMapCenter        20)
  1050. #define        (kInnerPushFromMapCenter         0)    
  1051.                                             
  1052. //////////////////////////////////////////////////////////////////////
  1053. // player definitions
  1054. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  1055. #define        (kPlayerInnerRadius,            0.6)
  1056. #define        (kPlayerOuterRadius,            0.99)
  1057. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1058. #define        (kPlayerPercentFlat,            Between(.95, .95))
  1059. #define        (kPlayerLandChaos,            0.8)
  1060. #define        (kPlayerLandClumps,            Between(2, 2))
  1061. #define        (kPlayerFlatChaos,            0.8)
  1062. #define        (kPlayerFlatClumps,            Between(1, 2))
  1063. #define        (kPlayerTreePercentage,            0.15)
  1064.  
  1065. //////////////////////////////////////////////////////////////////////
  1066. // inner neutral definitions
  1067. #define        (kNeutralInnerRadius,            0.3)
  1068. #define        (kNeutralOuterRadius,            0.4)
  1069. #define        (kNeutralOptimalFactor,            0.7)
  1070. #define        (kNumInnerNeutrals,                 Between(4, 4))
  1071. #define        (kInnerNeutralPercentLand,        0.14)
  1072. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1073. #define        (kInnerNeutralTreePercentage,          0.15)
  1074. #define        (kInnerNeutralLandChaos,        0.8)
  1075. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1076. #define        (kInnerNeutralFlatChaos,        0.8)
  1077. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1078.  
  1079. //////////////////////////////////////////////////////////////////////
  1080. // outer neutral definitions
  1081. #define        (kNumOuterNeutrals,            Between(9, 9))
  1082. #define        (kOuterNeutralPercentLand,        0.3)
  1083. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1084. #define        (kOuterNeutralTreePercentage,          0.2)
  1085. #define        (kOuterNeutralLandChaos,        0.8)
  1086. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1087. #define        (kOuterNeutralFlatChaos,        0.8)
  1088. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1089.  
  1090. //////////////////////////////////////////////////////////////////////
  1091. // resource definitions
  1092. #define        (kMaxResourceElevation,            4)
  1093. #define        (kResourceToEdgeDistance,        2)
  1094. #define        (kResourceToWaterDistance,        4)
  1095.  
  1096. #define        (kAnimalPerPlayer,            0)
  1097. #define        (kAnimalPerNeutral,            0)
  1098.  
  1099. #define        (kBerryPerPlayer,                1)
  1100. #define        (kBerryPerNeutral,            0)
  1101.  
  1102. #define        (kFishPerPlayer,                0)
  1103. #define        (kFishPerNeutral,                0)
  1104.  
  1105. #define        (kGoldPerPlayer,                1)
  1106. #define        (kGoldPerNeutral,                6)
  1107.  
  1108. #define        (kOilPerPlayer,                0)
  1109. #define        (kOilPerNeutral,                0)
  1110.  
  1111. #define        (kSteelPerPlayer,                1)
  1112. #define        (kSteelPerNeutral,            6)
  1113.  
  1114. #define        (kStonePerPlayer,                1)
  1115. #define        (kStonePerNeutral,            2)
  1116.  
  1117. #define        (kTreePerPlayer,                0)
  1118. #define        (kTreePerNeutral,                0)
  1119.  
  1120.  
  1121. //////////////////////////////////////////////////////////////////////
  1122. // forest definitions
  1123. #define        (kForestFreeRadius,                6.0)
  1124. #define        (kForestsPerPlayer,                1 )
  1125. #define        (kForestChaosLevel,                0.1)
  1126. #define        (kMaxClumpsPerForest,                  2)
  1127.  
  1128.  
  1129. #elif Is13Players
  1130. //////////////////////////////////////////////////////////////////////
  1131. // 13 PLAYERS...
  1132. //////////////////////////////////////////////////////////////////////
  1133.  
  1134. //////////////////////////////////////////////////////////////////////
  1135. // terrain definitions
  1136. #define        (kMaxIntElevation,            12)
  1137. #define        (kElevationScale,                Between(1, 1))
  1138. #define        (kHeightMapChaos,                Between(20, 50))
  1139.  
  1140. #define        (kMinimumStartPositionToMapEdge    1)
  1141. #define        (kOuterPushFromMapCenter        20)
  1142. #define        (kInnerPushFromMapCenter         0)    
  1143.                                             
  1144. //////////////////////////////////////////////////////////////////////
  1145. // player definitions
  1146. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  1147. #define        (kPlayerInnerRadius,            0.6)
  1148. #define        (kPlayerOuterRadius,            0.99)
  1149. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1150. #define        (kPlayerPercentFlat,            Between(.95, .95))
  1151. #define        (kPlayerLandChaos,            0.8)
  1152. #define        (kPlayerLandClumps,            Between(2, 2))
  1153. #define        (kPlayerFlatChaos,            0.8)
  1154. #define        (kPlayerFlatClumps,            Between(1, 2))
  1155. #define        (kPlayerTreePercentage,            0.15)
  1156.  
  1157. //////////////////////////////////////////////////////////////////////
  1158. // inner neutral definitions
  1159. #define        (kNeutralInnerRadius,            0.3)
  1160. #define        (kNeutralOuterRadius,            0.4)
  1161. #define        (kNeutralOptimalFactor,            0.7)
  1162. #define        (kNumInnerNeutrals,                 Between(4, 4))
  1163. #define        (kInnerNeutralPercentLand,        0.14)
  1164. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1165. #define        (kInnerNeutralTreePercentage,          0.15)
  1166. #define        (kInnerNeutralLandChaos,        0.8)
  1167. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1168. #define        (kInnerNeutralFlatChaos,        0.8)
  1169. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1170.  
  1171. //////////////////////////////////////////////////////////////////////
  1172. // outer neutral definitions
  1173. #define        (kNumOuterNeutrals,            Between(9, 9))
  1174. #define        (kOuterNeutralPercentLand,        0.3)
  1175. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1176. #define        (kOuterNeutralTreePercentage,          0.2)
  1177. #define        (kOuterNeutralLandChaos,        0.8)
  1178. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1179. #define        (kOuterNeutralFlatChaos,        0.8)
  1180. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1181.  
  1182. //////////////////////////////////////////////////////////////////////
  1183. // resource definitions
  1184. #define        (kMaxResourceElevation,            4)
  1185. #define        (kResourceToEdgeDistance,        2)
  1186. #define        (kResourceToWaterDistance,        4)
  1187.  
  1188. #define        (kAnimalPerPlayer,            0)
  1189. #define        (kAnimalPerNeutral,            0)
  1190.  
  1191. #define        (kBerryPerPlayer,                1)
  1192. #define        (kBerryPerNeutral,            0)
  1193.  
  1194. #define        (kFishPerPlayer,                0)
  1195. #define        (kFishPerNeutral,                0)
  1196.  
  1197. #define        (kGoldPerPlayer,                1)
  1198. #define        (kGoldPerNeutral,                6)
  1199.  
  1200. #define        (kOilPerPlayer,                0)
  1201. #define        (kOilPerNeutral,                0)
  1202.  
  1203. #define        (kSteelPerPlayer,                1)
  1204. #define        (kSteelPerNeutral,            6)
  1205.  
  1206. #define        (kStonePerPlayer,                1)
  1207. #define        (kStonePerNeutral,            2)
  1208.  
  1209. #define        (kTreePerPlayer,                0)
  1210. #define        (kTreePerNeutral,                0)
  1211.  
  1212.  
  1213. //////////////////////////////////////////////////////////////////////
  1214. // forest definitions
  1215. #define        (kForestFreeRadius,                6.0)
  1216. #define        (kForestsPerPlayer,                1 )
  1217. #define        (kForestChaosLevel,                0.1)
  1218. #define        (kMaxClumpsPerForest,                  2)
  1219.  
  1220.  
  1221. #elif Is14Players
  1222. //////////////////////////////////////////////////////////////////////
  1223. // 14 PLAYERS...
  1224. //////////////////////////////////////////////////////////////////////
  1225.  
  1226. //////////////////////////////////////////////////////////////////////
  1227. // terrain definitions
  1228. #define        (kMaxIntElevation,            12)
  1229. #define        (kElevationScale,                Between(1, 1))
  1230. #define        (kHeightMapChaos,                Between(20, 50))
  1231.  
  1232. #define        (kMinimumStartPositionToMapEdge    1)
  1233. #define        (kOuterPushFromMapCenter        20)
  1234. #define        (kInnerPushFromMapCenter         0)    
  1235.                                             
  1236. //////////////////////////////////////////////////////////////////////
  1237. // player definitions
  1238. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  1239. #define        (kPlayerInnerRadius,            0.6)
  1240. #define        (kPlayerOuterRadius,            0.99)
  1241. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1242. #define        (kPlayerPercentFlat,            Between(.95, .95))
  1243. #define        (kPlayerLandChaos,            0.8)
  1244. #define        (kPlayerLandClumps,            Between(2, 2))
  1245. #define        (kPlayerFlatChaos,            0.8)
  1246. #define        (kPlayerFlatClumps,            Between(1, 2))
  1247. #define        (kPlayerTreePercentage,            0.15)
  1248.  
  1249. //////////////////////////////////////////////////////////////////////
  1250. // inner neutral definitions
  1251. #define        (kNeutralInnerRadius,            0.3)
  1252. #define        (kNeutralOuterRadius,            0.4)
  1253. #define        (kNeutralOptimalFactor,            0.7)
  1254. #define        (kNumInnerNeutrals,                 Between(4, 4))
  1255. #define        (kInnerNeutralPercentLand,        0.14)
  1256. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1257. #define        (kInnerNeutralTreePercentage,          0.15)
  1258. #define        (kInnerNeutralLandChaos,        0.8)
  1259. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1260. #define        (kInnerNeutralFlatChaos,        0.8)
  1261. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1262.  
  1263. //////////////////////////////////////////////////////////////////////
  1264. // outer neutral definitions
  1265. #define        (kNumOuterNeutrals,            Between(9, 9))
  1266. #define        (kOuterNeutralPercentLand,        0.3)
  1267. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1268. #define        (kOuterNeutralTreePercentage,          0.2)
  1269. #define        (kOuterNeutralLandChaos,        0.8)
  1270. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1271. #define        (kOuterNeutralFlatChaos,        0.8)
  1272. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1273.  
  1274. //////////////////////////////////////////////////////////////////////
  1275. // resource definitions
  1276. #define        (kMaxResourceElevation,            4)
  1277. #define        (kResourceToEdgeDistance,        2)
  1278. #define        (kResourceToWaterDistance,        4)
  1279.  
  1280. #define        (kAnimalPerPlayer,            0)
  1281. #define        (kAnimalPerNeutral,            0)
  1282.  
  1283. #define        (kBerryPerPlayer,                1)
  1284. #define        (kBerryPerNeutral,            0)
  1285.  
  1286. #define        (kFishPerPlayer,                0)
  1287. #define        (kFishPerNeutral,                0)
  1288.  
  1289. #define        (kGoldPerPlayer,                1)
  1290. #define        (kGoldPerNeutral,                6)
  1291.  
  1292. #define        (kOilPerPlayer,                0)
  1293. #define        (kOilPerNeutral,                0)
  1294.  
  1295. #define        (kSteelPerPlayer,                1)
  1296. #define        (kSteelPerNeutral,            6)
  1297.  
  1298. #define        (kStonePerPlayer,                1)
  1299. #define        (kStonePerNeutral,            2)
  1300.  
  1301. #define        (kTreePerPlayer,                0)
  1302. #define        (kTreePerNeutral,                0)
  1303.  
  1304.  
  1305. //////////////////////////////////////////////////////////////////////
  1306. // forest definitions
  1307. #define        (kForestFreeRadius,                6.0)
  1308. #define        (kForestsPerPlayer,                1 )
  1309. #define        (kForestChaosLevel,                0.1)
  1310. #define        (kMaxClumpsPerForest,                  2)
  1311.  
  1312.  
  1313. #elif Is15Players
  1314. //////////////////////////////////////////////////////////////////////
  1315. // 15 PLAYERS...
  1316. //////////////////////////////////////////////////////////////////////
  1317.  
  1318. //////////////////////////////////////////////////////////////////////
  1319. // terrain definitions
  1320. #define        (kMaxIntElevation,            12)
  1321. #define        (kElevationScale,                Between(1, 1))
  1322. #define        (kHeightMapChaos,                Between(20, 50))
  1323.  
  1324. #define        (kMinimumStartPositionToMapEdge    1)
  1325. #define        (kOuterPushFromMapCenter        20)
  1326. #define        (kInnerPushFromMapCenter         0)    
  1327.                                             
  1328. //////////////////////////////////////////////////////////////////////
  1329. // player definitions
  1330. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  1331. #define        (kPlayerInnerRadius,            0.6)
  1332. #define        (kPlayerOuterRadius,            0.99)
  1333. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1334. #define        (kPlayerPercentFlat,            Between(.95, .95))
  1335. #define        (kPlayerLandChaos,            0.8)
  1336. #define        (kPlayerLandClumps,            Between(2, 2))
  1337. #define        (kPlayerFlatChaos,            0.8)
  1338. #define        (kPlayerFlatClumps,            Between(1, 2))
  1339. #define        (kPlayerTreePercentage,            0.15)
  1340.  
  1341. //////////////////////////////////////////////////////////////////////
  1342. // inner neutral definitions
  1343. #define        (kNeutralInnerRadius,            0.3)
  1344. #define        (kNeutralOuterRadius,            0.4)
  1345. #define        (kNeutralOptimalFactor,            0.7)
  1346. #define        (kNumInnerNeutrals,                 Between(4, 4))
  1347. #define        (kInnerNeutralPercentLand,        0.14)
  1348. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1349. #define        (kInnerNeutralTreePercentage,          0.15)
  1350. #define        (kInnerNeutralLandChaos,        0.8)
  1351. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1352. #define        (kInnerNeutralFlatChaos,        0.8)
  1353. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1354.  
  1355. //////////////////////////////////////////////////////////////////////
  1356. // outer neutral definitions
  1357. #define        (kNumOuterNeutrals,            Between(9, 9))
  1358. #define        (kOuterNeutralPercentLand,        0.3)
  1359. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1360. #define        (kOuterNeutralTreePercentage,          0.2)
  1361. #define        (kOuterNeutralLandChaos,        0.8)
  1362. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1363. #define        (kOuterNeutralFlatChaos,        0.8)
  1364. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1365.  
  1366. //////////////////////////////////////////////////////////////////////
  1367. // resource definitions
  1368. #define        (kMaxResourceElevation,            4)
  1369. #define        (kResourceToEdgeDistance,        2)
  1370. #define        (kResourceToWaterDistance,        4)
  1371.  
  1372. #define        (kAnimalPerPlayer,            0)
  1373. #define        (kAnimalPerNeutral,            0)
  1374.  
  1375. #define        (kBerryPerPlayer,                1)
  1376. #define        (kBerryPerNeutral,            0)
  1377.  
  1378. #define        (kFishPerPlayer,                0)
  1379. #define        (kFishPerNeutral,                0)
  1380.  
  1381. #define        (kGoldPerPlayer,                1)
  1382. #define        (kGoldPerNeutral,                6)
  1383.  
  1384. #define        (kOilPerPlayer,                0)
  1385. #define        (kOilPerNeutral,                0)
  1386.  
  1387. #define        (kSteelPerPlayer,                1)
  1388. #define        (kSteelPerNeutral,            6)
  1389.  
  1390. #define        (kStonePerPlayer,                1)
  1391. #define        (kStonePerNeutral,            2)
  1392.  
  1393. #define        (kTreePerPlayer,                0)
  1394. #define        (kTreePerNeutral,                0)
  1395.  
  1396.  
  1397. //////////////////////////////////////////////////////////////////////
  1398. // forest definitions
  1399. #define        (kForestFreeRadius,                6.0)
  1400. #define        (kForestsPerPlayer,                1 )
  1401. #define        (kForestChaosLevel,                0.1)
  1402. #define        (kMaxClumpsPerForest,                  2)
  1403.  
  1404.  
  1405. #elif Is16Players
  1406. //////////////////////////////////////////////////////////////////////
  1407. // 16 PLAYERS...
  1408. //////////////////////////////////////////////////////////////////////
  1409.  
  1410. //////////////////////////////////////////////////////////////////////
  1411. // terrain definitions
  1412. #define        (kMaxIntElevation,            12)
  1413. #define        (kElevationScale,                Between(1, 1))
  1414. #define        (kHeightMapChaos,                Between(20, 50))
  1415.  
  1416. #define        (kMinimumStartPositionToMapEdge    1)
  1417. #define        (kOuterPushFromMapCenter        20)
  1418. #define        (kInnerPushFromMapCenter         0)    
  1419.                                             
  1420. //////////////////////////////////////////////////////////////////////
  1421. // player definitions
  1422. #define        (kMaxAngleBetweenTeamMembers,        32.0)
  1423. #define        (kPlayerInnerRadius,            0.6)
  1424. #define        (kPlayerOuterRadius,            0.99)
  1425. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1426. #define        (kPlayerPercentFlat,            Between(.95, .95))
  1427. #define        (kPlayerLandChaos,            0.8)
  1428. #define        (kPlayerLandClumps,            Between(2, 2))
  1429. #define        (kPlayerFlatChaos,            0.8)
  1430. #define        (kPlayerFlatClumps,            Between(1, 2))
  1431. #define        (kPlayerTreePercentage,            0.15)
  1432.  
  1433. //////////////////////////////////////////////////////////////////////
  1434. // inner neutral definitions
  1435. #define        (kNeutralInnerRadius,            0.3)
  1436. #define        (kNeutralOuterRadius,            0.4)
  1437. #define        (kNeutralOptimalFactor,            0.7)
  1438. #define        (kNumInnerNeutrals,                 Between(4, 4))
  1439. #define        (kInnerNeutralPercentLand,        0.14)
  1440. #define        (kInnerNeutralPercentFlat,        Between(0.9, 0.9))
  1441. #define        (kInnerNeutralTreePercentage,          0.15)
  1442. #define        (kInnerNeutralLandChaos,        0.8)
  1443. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1444. #define        (kInnerNeutralFlatChaos,        0.8)
  1445. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1446.  
  1447. //////////////////////////////////////////////////////////////////////
  1448. // outer neutral definitions
  1449. #define        (kNumOuterNeutrals,            Between(9, 9))
  1450. #define        (kOuterNeutralPercentLand,        0.3)
  1451. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1452. #define        (kOuterNeutralTreePercentage,          0.2)
  1453. #define        (kOuterNeutralLandChaos,        0.8)
  1454. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1455. #define        (kOuterNeutralFlatChaos,        0.8)
  1456. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1457.  
  1458. //////////////////////////////////////////////////////////////////////
  1459. // resource definitions
  1460. #define        (kMaxResourceElevation,            4)
  1461. #define        (kResourceToEdgeDistance,        2)
  1462. #define        (kResourceToWaterDistance,        4)
  1463.  
  1464. #define        (kAnimalPerPlayer,            0)
  1465. #define        (kAnimalPerNeutral,            0)
  1466.  
  1467. #define        (kBerryPerPlayer,                1)
  1468. #define        (kBerryPerNeutral,            0)
  1469.  
  1470. #define        (kFishPerPlayer,                0)
  1471. #define        (kFishPerNeutral,                0)
  1472.  
  1473. #define        (kGoldPerPlayer,                1)
  1474. #define        (kGoldPerNeutral,                6)
  1475.  
  1476. #define        (kOilPerPlayer,                0)
  1477. #define        (kOilPerNeutral,                0)
  1478.  
  1479. #define        (kSteelPerPlayer,                1)
  1480. #define        (kSteelPerNeutral,            6)
  1481.  
  1482. #define        (kStonePerPlayer,                1)
  1483. #define        (kStonePerNeutral,            2)
  1484.  
  1485. #define        (kTreePerPlayer,                0)
  1486. #define        (kTreePerNeutral,                0)
  1487.  
  1488.  
  1489. //////////////////////////////////////////////////////////////////////
  1490. // forest definitions
  1491. #define        (kForestFreeRadius,                6.0)
  1492. #define        (kForestsPerPlayer,                1 )
  1493. #define        (kForestChaosLevel,                0.1)
  1494. #define        (kMaxClumpsPerForest,                  2)
  1495.  
  1496.  
  1497. //////////////////////////////////////////////////////////////////////
  1498. // End of if...elif... command
  1499. #endif
  1500.  
  1501. #endif        // NOTDEFINED(HIGHLANDS_TINY_RMV)
  1502.